packages/svelte-query-devtools/package.json (1)

57-58: Keep Svelte peer ranges aligned across packages.

To reduce confusion for consumers, let’s mirror the adapter’s svelte peer range (^5.7.0). It keeps the expectation consistent and avoids scenarios where the devtools appear to accept lower minors than the core package actually supports.

packages/svelte-query-persist-client/eslint.config.js (1)

20-24: Limit the blanket svelte/no-unused-svelte-ignore disable.

Turning this rule off repo-wide removes our guardrail against stale @svelte-ignore comments. If the disable is only here to dodge current eslint-plugin-svelte false positives with runes, please either scope it to the specific files that hit the issue or leave an inline TODO pointing to the upstream tracker so we remember to re-enable it. Right now it’s a silent, permanent relax.

examples/svelte/star-wars/src/routes/films/[filmId]/Character.svelte (2)

11-14: Pass AbortSignal, guard when id is empty, and avoid subtle closure mismatch

Improve cancellation and robustness by using the QueryFunctionContext (provides signal and queryKey) and guarding on a falsy characterId. This also avoids relying on a closure for id resolution.

Apply this diff:

-  const query = createQuery(() => ({
-    queryKey: ['character', characterId],
-    queryFn: getCharacter,
-  }))
+  const query = createQuery(() => ({
+    queryKey: ['character', characterId] as const,
+    enabled: !!characterId,
+    queryFn: async ({ signal, queryKey }) => {
+      const [, id] = queryKey as ['character', string]
+      const res = await fetch(`https://swapi.dev/api/people/${id}/`, { signal })
+      if (!res.ok) throw new Error(`Failed to fetch character ${id}`)
+      return res.json()
+    },
+  }))

Based on learnings

---

17-17: Prefer boolean flag over string comparison

Use the built-in boolean for readability and to avoid typos:

-{#if query.status === 'success'}
+{#if query.isSuccess}

packages/svelte-query-devtools/src/Devtools.svelte (1)

90-105: Guard setter calls with optional call chaining

If any setter isn’t present on the queried devtools version, current calls can throw at runtime. Use optional call chaining on the method.

Apply:

-    $effect(() => {
-      devtools?.setButtonPosition(buttonPosition)
-    })
+    $effect(() => {
+      devtools?.setButtonPosition?.(buttonPosition)
+    })
 
-    $effect(() => {
-      devtools?.setPosition(position)
-    })
+    $effect(() => {
+      devtools?.setPosition?.(position)
+    })
 
-    $effect(() => {
-      devtools?.setInitialIsOpen(initialIsOpen)
-    })
+    $effect(() => {
+      devtools?.setInitialIsOpen?.(initialIsOpen)
+    })
 
-    $effect(() => {
-      devtools?.setErrorTypes(errorTypes)
-    })
+    $effect(() => {
+      devtools?.setErrorTypes?.(errorTypes)
+    })

.changeset/pink-pots-jam.md (1)

7-7: Make the changeset note more actionable (add concrete migration pointers).

Consider briefly calling out key breaking changes and the new invocation pattern to reduce upgrade friction.

Apply this diff to enrich the note:

-BREAKING: Migrate to svelte runes (svelte v5+). Please see documentation for migration guide.
+BREAKING: Migrate to Svelte runes (Svelte v5+). See the migration guide in the docs.
+
+- Queries now use factory-wrapped options, e.g. `createQuery(() => ({ ... }))`, `createInfiniteQuery(() => ({ ... }))`.
+- Components adopt `$props()` and render children via `{@render children?.()}`.
+- Requires Svelte 5+ (ensure `compilerOptions.runes` is enabled).

examples/svelte/load-more-infinite-scroll/src/routes/+layout.svelte (1)

7-8: Guard children render to avoid runtime errors when no slot content.

If children are absent, calling children() throws. Use optional chaining.

Apply this diff:

-    {@render children()}
+    {@render children?.()}

Also applies to: 20-20

examples/svelte/star-wars/src/routes/+layout.svelte (1)

7-8: Use optional chaining when rendering children.

Prevents a crash if children are missing.

Apply this diff:

-  {@render children()}
+  {@render children?.()}

Also applies to: 30-30

examples/svelte/basic/src/routes/+layout.svelte (1)

9-10: Use optional chaining for resilient children render.

Avoids invoking an undefined render function.

Apply this diff:

-    {@render children()}
+    {@render children?.()}

Also applies to: 26-27

packages/svelte-query/tests/infiniteQueryOptions/infiniteQueryOptions.test-d.ts (1)

41-44: Fix stale comment reference.

The comment still mentions useInfiniteQuery.

Apply this diff:

-    // known issue: type of pageParams is unknown when returned from useInfiniteQuery
+    // known issue: type of pageParams is unknown when returned from createInfiniteQuery

examples/svelte/basic/src/routes/[postId]/+page.svelte (1)

4-4: Preserve types by annotating $props() extraction.

Without the prop export, data loses its PageData type. Add the type import and annotate the destructure.

Apply this diff:

-  const { data } = $props()
+  const { data }: { data: PageData } = $props()

Add this import at the top of the script block:

import type { PageData } from './$types'

examples/svelte/optimistic-updates/src/routes/+layout.svelte (1)

7-8: Optional-chain children render.

Prevents errors if no children are provided.

Apply this diff:

-    {@render children()}
+    {@render children?.()}

Also applies to: 20-20

examples/svelte/ssr/src/routes/[postId]/+page.svelte (1)

4-4: Optional: add type to props destructure for better DX.

Type the data prop inline to keep editor types without extra imports.

Apply:

-  const { data } = $props()
+  const { data }: { data: import('./$types').PageData } = $props()

examples/svelte/star-wars/src/routes/films/[filmId]/+page.svelte (1)

6-16: Inline queryFn with AbortSignal and capture id once.

Improves cancellation and avoids implicit dependency on page in a separate function.

Apply:

-  const getFilm = async () => {
-    const res = await fetch(
-      `https://swapi.dev/api/films/${page.params.filmId}/`,
-    )
-    return await res.json()
-  }
-
-  const query = createQuery(() => ({
-    queryKey: ['film', page.params.filmId],
-    queryFn: getFilm,
-  }))
+  const query = createQuery(() => {
+    const id = page.params.filmId
+    return {
+      queryKey: ['film', id],
+      queryFn: async ({ signal }) =>
+        fetch(`https://swapi.dev/api/films/${id}/`, { signal }).then((r) =>
+          r.json(),
+        ),
+    }
+  })

examples/svelte/simple/src/lib/Simple.svelte (1)

12-18: Use AbortSignal in queryFn to support cancellation.

Prevents in-flight fetches from completing after unmount/param change.

Apply:

-  const query = createQuery<Repo>(() => ({
+  const query = createQuery<Repo>(() => ({
     queryKey: ['repoData'],
-    queryFn: async () =>
-      await fetch('https://api.github.com/repos/TanStack/query').then((r) =>
-        r.json(),
-      ),
+    queryFn: async ({ signal }) =>
+      fetch('https://api.github.com/repos/TanStack/query', { signal }).then((r) =>
+        r.json(),
+      ),
   }))

examples/svelte/optimistic-updates/src/routes/+page.svelte (2)

39-43: Strengthen error typing or guard for message

todos.error defaults to unknown; accessing message may fail typing. Either annotate Error as the second generic or guard in template.

Option A (type-safe generics):

-const todos = createQuery<Todos>(() => ({
+const todos = createQuery<Todos, Error>(() => ({
  queryKey: ['optimistic'],
  queryFn: fetchTodos,
}))

Option B (template-safe guard):

-{#if todos.error}
-  An error has occurred:
-  {todos.error.message}
+{#if todos.error}
+  An error has occurred:
+  {todos.error instanceof Error ? todos.error.message : String(todos.error)}
{/if}

Also applies to: 102-108

---

44-78: Optional: add mutation generics for better type safety

You can tighten types for err/variables/context to remove any casts and improve DX.

Example:

type Ctx = { previousTodos?: Todos }
const addTodoMutation = createMutation<Todo, Error, string, Ctx>(() => ({
  // ...
  onError: (_err, _variables, context) => {
    if (context?.previousTodos) {
      client.setQueryData(['optimistic'], context.previousTodos)
    }
  },
}))

examples/svelte/load-more-infinite-scroll/src/lib/LoadMore.svelte (2)

26-31: Guard error message for unknown error types

query.error may not be an Error; guard to avoid type/runtime issues.

-{#if query.error}
-  <span>Error: {query.error.message}</span>
+{#if query.error}
+  <span>Error: {query.error instanceof Error ? query.error.message : String(query.error)}</span>
{/if}

---

50-55: Prefer isFetchingNextPage for the button label

Using isFetching can show “Loading more...” during other refetches. isFetchingNextPage better reflects the button action.

-      {#if query.isFetching}
+      {#if query.isFetchingNextPage}
         Loading more...
       {:else if query.hasNextPage}
         Load More
       {:else}Nothing more to load{/if}

packages/svelte-query/tests/utils.svelte.ts (1)

14-22: Tighten promiseWithResolvers types

Expose standard PromiseLike resolution and unknown for reject reason.

-export function promiseWithResolvers<T>() {
-  let resolve: (value: T) => void
-  let reject: (reason?: any) => void
+export function promiseWithResolvers<T>() {
+  let resolve!: (value: T | PromiseLike<T>) => void
+  let reject!: (reason?: unknown) => void
   const promise = new Promise<T>((res, rej) => {
     resolve = res
     reject = rej
   })
-  return { promise, resolve: resolve!, reject: reject! }
+  return { promise, resolve, reject }
 }

examples/svelte/basic/src/lib/Posts.svelte (1)

7-7: Use const for non-mutated value

limit is never reassigned; prefer const.

-let limit = 10
+const limit = 10

packages/svelte-query/src/createMutation.svelte.ts (2)

48-52: Batch updates with notifyManager.batch, not batchCalls invoked immediately

batchCalls returns a wrapper for callbacks; for inline updates, batch is the simpler/clearer choice.

Apply this diff:

-  const unsubscribe = observer.subscribe((val) => {
-    notifyManager.batchCalls(() => {
-      Object.assign(result, val)
-    })()
-  })
+  const unsubscribe = observer.subscribe((val) => {
+    notifyManager.batch(() => {
+      Object.assign(result, val)
+    })
+  })

---

60-69: Avoid spreading result on every get; it over‑tracks and allocates

Spreading result in the get trap reads all fields (over‑tracking) and allocates a new object for each property access. Return only the requested property.

Apply this diff:

-    get: (_, prop) => {
-      const r = {
-        ...result,
-        mutate,
-        mutateAsync: result.mutate,
-      }
-      if (prop == 'value') return r
-      // @ts-expect-error
-      return r[prop]
-    },
+    get: (_, prop) => {
+      if (prop === 'value') {
+        return { ...result, mutate, mutateAsync: result.mutate }
+      }
+      if (prop === 'mutate') return mutate
+      if (prop === 'mutateAsync') return result.mutate
+      // @ts-expect-error
+      return (result as any)[prop]
+    },

examples/svelte/ssr/src/lib/Post.svelte (1)

8-11: Guard the query with enabled to avoid fetching when postId is falsy

Prevents unnecessary fetches and aligns with the template’s conditional.

Apply this diff:

   const post = createQuery<Post>(() => ({
     queryKey: ['post', postId],
     queryFn: () => api().getPostById(postId),
+    enabled: !!postId,
   }))

packages/svelte-query-persist-client/src/PersistQueryClientProvider.svelte (4)

23-29: Avoid passing onSuccess/onError through to QueryClientProvider

Extract them explicitly so they aren’t spread into .

Apply this diff:

-  let {
-    client,
-    children,
-    persistOptions,
-    ...props
-  }: PersistQueryClientProviderProps = $props()
+  let {
+    client,
+    children,
+    persistOptions,
+    onSuccess,
+    onError,
+    ...restProps
+  }: PersistQueryClientProviderProps = $props()

---

39-41: Return undefined during restore instead of a noop cleanup

Slightly cleaner effect cleanup semantics.

Apply this diff:

-  $effect(() => {
-    return isRestoring.current ? () => {} : persistQueryClientSubscribe(options)
-  })
+  $effect(() =>
+    isRestoring.current ? undefined : persistQueryClientSubscribe(options),
+  )

---

46-47: Reference extracted callbacks directly

Avoid reading from the spread props bag.

Apply this diff:

-      .then(() => props.onSuccess?.())
-      .catch(() => props.onError?.())
+      .then(() => onSuccess?.())
+      .catch(() => onError?.())

---

54-56: Spread only remaining provider props

Prevents leaking unrelated props to the provider.

Apply this diff:

-<QueryClientProvider {client} {...props}>
+<QueryClientProvider {client} {...restProps}>

packages/svelte-query/tests/useIsMutating/BaseExample.svelte (1)

18-18: Use Svelte event directive on:click instead of onclick

onclick may not attach as an event handler in Svelte templates; on:click is the idiomatic directive.

Apply this diff:

-<button onclick={() => mutation.mutate()}>Trigger</button>
+<button on:click={() => mutation.mutate()}>Trigger</button>

If you intentionally rely on a Svelte 5 change that supports onclick, please confirm; otherwise switch to on:click.

packages/svelte-query/tests/createQuery.svelte.test.ts (1)

228-236: Avoid wrapping createQuery in $derived

$derived here would recreate the query instance when dependencies change. Use the query result directly.

Apply this diff:

-      const query = $derived(
-        createQuery<string, Error>(
-          () => ({
-            queryKey: key,
-            queryFn: () => promise,
-          }),
-          () => queryClient,
-        ),
-      )
+      const query = createQuery<string, Error>(
+        () => ({
+          queryKey: key,
+          queryFn: () => promise,
+        }),
+        () => queryClient,
+      )

packages/svelte-query/tests/createQueries.svelte.test.ts (3)

370-379: Avoid sparse arrays with Array(50).map in runtime paths.

Array(50).map produces a sparse array (map won’t run). Use Array.from to avoid accidental runtime surprises even in type-centric tests.

Apply:

-          queries: Array(50).map((_, i) => ({
+          queries: Array.from({ length: 50 }, (_, i) => ({
             queryKey: ['key', i] as const,
             queryFn: () => i + 10,
-          })),
+          })),

---

486-495: Same sparse array issue (with select).

Apply:

-          queries: Array(50).map((_, i) => ({
+          queries: Array.from({ length: 50 }, (_, i) => ({
             queryKey: ['key', i] as const,
             queryFn: () => i + 10,
             select: (data: number) => data.toString(),
-          })),
+          })),

---

583-593: Same sparse array issue (fetch/Promise).

Apply:

-          queries: Array(50).map((_, i) => ({
+          queries: Array.from({ length: 50 }, (_, i) => ({
             queryKey: ['key', i] as const,
             queryFn: () =>
               fetch('return Promise<any>').then((resp) => resp.json()),
-          })),
+          })),

examples/svelte/ssr/src/routes/[postId]/+page.ts (1)

7-7: Specify radix for parseInt.

Avoid implicit radix to prevent edge-case parsing.

Apply:

-  const postId = parseInt(params.postId)
+  const postId = parseInt(params.postId, 10)

examples/svelte/auto-refetching/src/routes/+layout.svelte (2)

7-8: Type the children prop for TS (Svelte 5 Snippet).

For better DX and to avoid implicit any, type children as Snippet.

 <script lang="ts">
+  import type { Snippet } from 'svelte'
   import '../app.css'
   import { browser } from '$app/environment'
   import { QueryClientProvider, QueryClient } from '@tanstack/svelte-query'
   import { SvelteQueryDevtools } from '@tanstack/svelte-query-devtools'

-  const { children } = $props()
+  const { children }: { children: Snippet } = $props()

---

18-23: Avoid SSR mismatch: render Devtools only in the browser.

SvelteQueryDevtools should be gated by browser to prevent SSR/CSR markup mismatch and unnecessary server work.

Suggested change:

<QueryClientProvider client={queryClient}>
  <main>
    {@render children()}
  </main>
  {#if browser}
    <SvelteQueryDevtools />
  {/if}
</QueryClientProvider>

examples/svelte/star-wars/src/routes/films/+page.svelte (1)

9-41: Rune migration looks good; consider adding a keyed each for stability.

• The function-wrapped createQuery and direct query.* access align with the runes adapter.
• Add a stable key to the each block to minimize DOM churn:

-    {#each query.data.results as film}
+    {#each query.data.results as film (film.url)}

packages/svelte-query/src/useIsRestoring.ts (1)

2-6: Type alignment check: Box shape vs context return.

Confirm getIsRestoringContext() returns a Box with the same shape you export (e.g., current vs value). If consumers expect isRestoring.current, returning a mismatched shape will break them. If there’s a possible “no provider” path, consider a safe default.

examples/svelte/playground/src/routes/+page.svelte (1)

32-32: Optional: ensure numeric coercion on inputs if needed.

bind:value on number inputs should yield numbers, but if any path treats them as strings, coerce explicitly (e.g., bind:value={staleTime.value} and validate downstream) to avoid accidental string math.

Also applies to: 42-42, 55-55, 65-65, 74-74

packages/svelte-query/tests/createInfiniteQuery/createInfiniteQuery.svelte.test.ts (1)

18-33: LGTM on ref migration; you can make states const.

You mutate states.value but don’t reassign states; prefer const for clarity:

-    let states = ref<Array<QueryObserverResult>>([])
+    const states = ref<Array<QueryObserverResult>>([])

examples/svelte/star-wars/src/routes/characters/+page.svelte (1)

9-36: Rune migration looks good; add keyed each for better diffing.

Same as films example, key the each block:

-    {#each query.data.results as person}
+    {#each query.data.results as person (person.url)}

packages/svelte-query/tests/QueryClientProvider/ParentComponent.svelte (1)

4-7: LGTM; optional ergonomic tweak for props typing.

You can type $props directly to avoid inline annotation:

-  let { queryClient }: { queryClient: QueryClient } = $props()
+  const { queryClient } = $props<{ queryClient: QueryClient }>()

packages/svelte-query/tests/createInfiniteQuery/BaseExample.svelte (1)

12-20: Rune migration looks correct; consider avoiding ts-ignore with a typed snapshot helper.

The new Accessor-based call and client factory are consistent. The $effect + untrack pattern is fine. To avoid ts-expect-error/svelte-ignore, you can cast the snapshot once via a helper.

Example:

+  const snapshot = () => $state.snapshot(query) as unknown as QueryObserverResult
  $effect(() => {
-    // @ts-expect-error
-    // svelte-ignore state_snapshot_uncloneable
-    states.value = [...untrack(() => states.value), $state.snapshot(query)]
+    states.value = [...untrack(() => states.value), snapshot()]
  })

Also applies to: 22-26

packages/svelte-query/src/useIsMutating.svelte.ts (2)

12-15: Batch cache notifications to reduce redundant recomputations.

Wrap the subscriber with notifyManager.batchCalls to coalesce updates (mirrors prior store-based patterns and React/Solid adapters).

Apply:

+import { notifyManager } from '@tanstack/query-core'
 
 export function useIsMutating(
   filters?: MutationFilters,
   queryClient?: QueryClient,
 ): ReactiveValue<number> {
   const client = useQueryClient(queryClient)
   const cache = client.getMutationCache()
 
   return new ReactiveValue(
     () => client.isMutating(filters),
-    (update) => cache.subscribe(update),
+    (update) => cache.subscribe(notifyManager.batchCalls(() => update())),
   )
 }

---

5-8: Non-reactive filters/client params.

Passing plain filters/queryClient means changes to those won’t trigger recomputation until the cache emits an event. If that’s intentional, fine; otherwise consider Accessor<MutationFilters | QueryClient> for reactive args (aligns with other Accessor-based APIs).

Can you confirm the intended semantics for filters reactivity here?

packages/svelte-query/src/useIsFetching.svelte.ts (2)

12-15: Batch query cache notifications.

Use notifyManager.batchCalls to avoid excessive updates during bursts.

Apply:

+import { notifyManager } from '@tanstack/query-core'
 
 export function useIsFetching(
   filters?: QueryFilters,
   queryClient?: QueryClient,
 ): ReactiveValue<number> {
   const client = useQueryClient(queryClient)
   const queryCache = client.getQueryCache()
 
   return new ReactiveValue(
     () => client.isFetching(filters),
-    (update) => queryCache.subscribe(update),
+    (update) => queryCache.subscribe(notifyManager.batchCalls(() => update())),
   )
 }

---

5-8: Filters/client are non-reactive.

Same note as useIsMutating: if consumers expect filters changes to reflect immediately (without a cache event), consider Accessor parameters.

Is this API intentionally non-reactive for filters?

packages/svelte-query/src/HydrationBoundary.svelte (1)

10-15: Tighten Props typing and defaults.

Prefer optional props over unions-with-undefined for options/queryClient for readability; keep required children/state.

Apply:

-  type Props = {
-    children: Snippet
-    state: DehydratedState
-    options: HydrateOptions | undefined
-    queryClient: QueryClient | undefined
-  }
+  type Props = {
+    children: Snippet
+    state: DehydratedState
+    options?: HydrateOptions
+    queryClient?: QueryClient
+  }
 
   const {
     children,
     state,
-    options = undefined,
-    queryClient = undefined,
+    options,
+    queryClient,
   }: Props = $props()

Also applies to: 17-22, 27-27

packages/svelte-query/tests/QueryClientProvider/QueryClientProvider.svelte.test.ts (1)

15-29: Clean up QueryClient after test to prevent cross-test contamination.

Clear the client to avoid retained queries between tests.

Apply:

   test('Sets a specific cache for all queries to use', async () => {
     const queryClient = new QueryClient()
     const queryCache = queryClient.getQueryCache()
@@
     expect(queryCache.find({ queryKey: ['hello'] })).toBeDefined()
+    queryClient.clear()
   })

packages/svelte-query/tests/createInfiniteQuery/SelectExample.svelte (1)

12-24: Consistent runes migration; typings nit optional.

The Accessor-based call and untrack + snapshot pattern are consistent. Optionally avoid ts-ignore by casting a snapshot helper as noted in BaseExample.

Also applies to: 26-30, 33-33

packages/svelte-query-persist-client/tests/RemoveCache/Provider.svelte (1)

7-14: Widen onSuccess/onError to support async handlers

 interface Props {
   queryClient: QueryClient
   persistOptions: OmitKeyof<PersistQueryClientOptions, 'queryClient'>
-  onSuccess: () => void
-  onError: () => void
+  onSuccess: () => void | Promise<void>
+  onError: () => void | Promise<void>
 }

QueryClient and OmitKeyof are correctly re-exported from @tanstack/svelte-query.

packages/svelte-query/src/useMutationState.svelte.ts (2)

1-1: Batch cache notifications to avoid update thrashing

Wrap the subscription callback with notifyManager.batchCalls like the store-based variant to coalesce updates.

Apply this diff:

-import { replaceEqualDeep } from '@tanstack/query-core'
+import { notifyManager, replaceEqualDeep } from '@tanstack/query-core'
@@
-  $effect(() => {
-    const unsubscribe = mutationCache.subscribe(() => {
+  $effect(() => {
+    const unsubscribe = mutationCache.subscribe(
+      notifyManager.batchCalls(() => {
         const nextResult = replaceEqualDeep(
           result,
           getResult(mutationCache, options),
         )
         if (result !== nextResult) {
-          Object.assign(result, nextResult)
+          result.splice(0, result.length, ...nextResult)
         }
-    })
+      }),
+    )

Based on learnings.

Also applies to: 30-38

---

43-54: Remove dead/commented block

The alternative $effect block is outdated (references result.current/optionsRef) and can be removed.

Apply this diff:

-  /*  $effect(() => {
-    mutationCache.subscribe(() => {
-      const nextResult = replaceEqualDeep(
-        result.current,
-        getResult(mutationCache, optionsRef),
-      )
-      if (result.current !== nextResult) {
-        result = nextResult
-        //notifyManager.schedule(onStoreChange)
-      }
-    })
-  }) */

packages/svelte-query/src/context.ts (1)

27-35: Optional: return a stable default Box instance

Returning a new { current: false } each call can defeat identity checks. A module-level singleton default avoids churn.

Apply this diff:

+const _defaultIsRestoring: Box<boolean> = { current: false }
@@
-    return isRestoring ?? { current: false }
+    return isRestoring ?? _defaultIsRestoring
   } catch (error) {
-    return { current: false }
+    return _defaultIsRestoring
   }

packages/svelte-query-persist-client/tests/AwaitOnSuccess/Provider.svelte (1)

6-6: Align import path extension for NodeNext/ESM consistency

Other files import from utils.svelte.js. Consider using the .js extension here to avoid resolution issues in strict ESM setups.

Apply this diff:

-import { StatelessRef } from '../utils.svelte'
+import { StatelessRef } from '../utils.svelte.js'

If your tooling resolves extensionless paths reliably, feel free to keep as-is.

examples/svelte/playground/src/routes/TodosList.svelte (1)

33-36: Minor: use object shorthand in options

Small readability tweak; no behavior change.

-  const query = createQuery(() => ({
-    queryKey: ['todos', { filter: filter }],
-    queryFn: () => fetchTodos({ filter: filter }),
-  }))
+  const query = createQuery(() => ({
+    queryKey: ['todos', { filter }],
+    queryFn: () => fetchTodos({ filter }),
+  }))

packages/svelte-query/tests/containers.svelte.test.ts (1)

1-219: Solid coverage of proxy traps and reactivity

Great suite validating set/has/ownKeys/getOwnPropertyDescriptor traps, lazy access, arrays, and effect behavior.

Consider adding:

• A test for symbol keys in objects (ensuring ownKeys filtering works with PropertyKey beyond strings).
• An array test deleting a non-terminal index (e.g., delete ref[1]) to confirm length handling and visibility are as intended.

packages/svelte-query/src/createBaseQuery.svelte.ts (1)

60-66: Consider memory leak prevention for subscriptions

The effect correctly returns an unsubscribe function, but there's a potential issue: if isRestoring.current changes from true to false while the effect is running, the subscription won't be created until the next effect run.

Consider restructuring to handle the subscription more robustly:

  $effect(() => {
-    const unsubscribe = isRestoring.current
-      ? () => undefined
-      : observer.subscribe(() => update(createResult()))
-    observer.updateResult()
-    return unsubscribe
+    let unsubscribe: (() => void) | undefined
+    
+    if (!isRestoring.current) {
+      unsubscribe = observer.subscribe(() => update(createResult()))
+    }
+    observer.updateResult()
+    
+    return () => unsubscribe?.()
  })

examples/svelte/auto-refetching/src/routes/+page.svelte (2)

63-69: Prefer modern event handler syntax

While onsubmit works, consider using Svelte 5's event handler syntax for consistency.

-  onsubmit={(e) => {
+  onsubmit={(e: SubmitEvent) => {

---

88-88: Missing type safety for mutation parameter

The undefined parameter to clearMutation.mutate could be more explicit about intent.

Consider adding a comment or using void to make the intent clearer:

-    <button onclick={() => clearMutation.mutate(undefined)}> Clear All </button>
+    <button onclick={() => clearMutation.mutate(undefined /* no parameters required */)}> Clear All </button>

packages/svelte-query-persist-client/tests/RestoreCache/RestoreCache.svelte (1)

13-17: Unbounded state accumulation in tests

$effect pushes a new snapshot on every reactive update and never clears it. If the test expects only specific lifecycle points, consider constraining or cleaning up to avoid unbounded growth.

Example options:

• Guard to push only when fetchStatus/data change meaningfully.
• Add cleanup to reset states on destroy.

 $effect(() => {
   // svelte-ignore state_snapshot_uncloneable
   const snapshot = $state.snapshot(query)
   states.current.push(snapshot)
+  return () => {
+    // keep array instance but clear entries to avoid leaks across mounts
+    states.current.length = 0
+  }
 })

examples/svelte/playground/src/lib/stores.svelte.ts (1)

1-12: Type the setter parameter for better inference

Annotate newValue so ref preserves types in setters.

 export function ref<T>(initial: T) {
   let value = $state(initial)

   return {
     get value() {
       return value
     },
-    set value(newValue) {
+    set value(newValue: T) {
       value = newValue
     },
   }
 }

packages/svelte-query-persist-client/tests/FreshData/Provider.svelte (1)

8-14: Validate availability of OmitKeyof

OmitKeyof may not be exported by @tanstack/svelte-query. If it isn’t, switch to the built-in Omit utility type.

-  import type { OmitKeyof, QueryClient } from '@tanstack/svelte-query'
+  import type { QueryClient } from '@tanstack/svelte-query'
   import type { PersistQueryClientOptions } from '@tanstack/query-persist-client-core'
 ...
-    persistOptions: OmitKeyof<PersistQueryClientOptions, 'queryClient'>
+    persistOptions: Omit<PersistQueryClientOptions, 'queryClient'>

examples/svelte/playground/src/routes/EditTodo.svelte (1)

18-39: Minor: order existence check before snapshot

Avoid snapshotting a possibly undefined value; check first, then snapshot to keep intent clear.

-          const todo = $state.snapshot(list.value.find((d) => d.id === id))
-          if (!todo) {
+          const found = list.value.find((d) => d.id === id)
+          if (!found) {
             return reject(
               new Error(JSON.stringify({ fetchTodoById: { id } }, null, 2)),
             )
           }
-          resolve(todo)
+          resolve($state.snapshot(found))

packages/svelte-query/src/containers.svelte.ts (2)

87-103: Align array length to new value in update()

After removing/setting keys, explicitly set the array length to match the new array to avoid stale trailing entries.

   function update(newValue: T) {
     const existingKeys = Object.keys(out)
     const newKeys = Object.keys(newValue)
     const keysToRemove = existingKeys.filter((key) => !newKeys.includes(key))
     for (const key of keysToRemove) {
       // @ts-expect-error
       delete out[key]
     }
     for (const key of newKeys) {
       // @ts-expect-error
       // This craziness is required because Tanstack Query defines getters for all of the keys on the object.
       // These getters track property access, so if we access all of them here, we'll end up tracking everything.
       // So we wrap the property access in a special function that we can identify later to lazily access the value.
       // (See above)
       out[key] = brand(() => newValue[key])
     }
+    if (Array.isArray(out) && Array.isArray(newValue)) {
+      // ensure visible length matches new array size
+      // @ts-expect-error
+      out.length = newValue.length
+    }
   }

Also applies to: 105-110

---

41-53: Preserve reactivity on direct assignments

When assigning to existing keys, the setter replaces state with a non-reactive value. Wrap non-branded values in $state.raw so future reads stay reactive; keep branded values as-is to retain laziness.

       Object.defineProperty(target, prop, {
         configurable: true,
         enumerable: true,
         get: () => {
           // If this is a lazy value, we need to call it.
           // We can't do something like typeof state === 'function'
           // because the value could actually be a function that we don't want to call.
           return state && isBranded(state) ? state() : state
         },
-        set: (v) => {
-          state = v
-        },
+        set: (v) => {
+          // keep laziness if branded; otherwise make it reactive
+          // @ts-expect-error
+          state = isBranded(v) ? v : $state.raw(v)
+        },
       })

Please re-run the affected containers tests to ensure this doesn’t inadvertently over-track properties (the branding path should still avoid eager access). Based on learnings

examples/svelte/star-wars/src/routes/characters/[characterId]/Film.svelte (1)

17-23: Prefer boolean flags over status string checks

For readability and resilience to status value changes, consider isSuccess.

Apply this diff:

-{#if query.status === 'success'}
+{#if query.isSuccess}

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Learnt from: TkDodo
PR: TanStack/query#9612
File: packages/query-async-storage-persister/src/asyncThrottle.ts:0-0
Timestamp: 2025-09-02T17:57:33.184Z
Learning: When importing from tanstack/query-core in other TanStack Query packages like query-async-storage-persister, a workspace dependency "tanstack/query-core": "workspace:*" needs to be added to the package.json.

Learnt from: oscartbeaumont
PR: TanStack/query#9564
File: packages/solid-query-devtools/src/production.tsx:2-3
Timestamp: 2025-08-19T03:18:18.303Z
Learning: In the solid-query-devtools package, the codebase uses a pattern of type-only default imports combined with typeof for component type annotations (e.g., `import type SolidQueryDevtoolsComp from './devtools'` followed by `typeof SolidQueryDevtoolsComp`). This pattern is consistently used across index.tsx and production.tsx files, and the maintainers prefer consistency over changing this approach.

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro

Configuration used: CodeRabbit UI

Review profile: CHILL

Plan: Pro